home *** CD-ROM | disk | FTP | other *** search
/ Almathera Ten Pack 2: CDPD 1 / Almathera Ten on Ten - Disc 2: CDPD 1.iso / pd / 026-050 / 042 / mg1a / def.h < prev    next >
C/C++ Source or Header  |  1995-03-13  |  13KB  |  418 lines
  1. /*
  2.  * This file is the general header file for all parts
  3.  * of the MicroEMACS display editor. It contains all of the
  4.  * general definitions and macros. It also contains some
  5.  * conditional compilation flags. All of the per-system and
  6.  * per-terminal definitions are in special header files.
  7.  * The most common reason to edit this file would be to zap
  8.  * the definition of CVMVAS or BACKUP.
  9.  */
  10. #include    "sysdef.h"        /* Order is critical.        */
  11. #include    "ttydef.h"
  12. #include    <stdio.h>
  13.  
  14. /*
  15.  * If your system and/or compiler does not support the "void" type
  16.  * then define NO_VOID_TYPE in sysdef.h.  In the absence of some
  17.  * other definition for VOID, the default in that case will be to
  18.  * turn it into an int, which works with most compilers that don't
  19.  * support void.  In the absence of any definition of VOID or
  20.  * NO_VOID_TYPE, the default is to assume void is supported, which
  21.  * should be the case for most modern C compilers.
  22.  */
  23.  
  24. #ifndef VOID
  25. #ifdef NO_VOID_TYPE
  26. #  define VOID int            /* Default for no void is int */
  27. #else
  28. #  define VOID void            /* Just use normal void */
  29. #endif /* NO_VOID_TYPE */
  30. #endif /* VOID */
  31.  
  32. /*
  33.  * Table sizes, etc.
  34.  */
  35. #ifdef    HASH
  36. #define    NSHASH    31            /* Symbol table hash size.    */
  37. #endif
  38. #define    NFILEN    80            /* Length, file name.        */
  39. #define    NBUFN    24            /* Length, buffer name.        */
  40. #ifndef NLINE            /* allow it to be defined in makefile */
  41. #define    NLINE    256            /* Length, line.        */
  42. #endif
  43. #define    NKBDM    256            /* Length, keyboard macro.    */
  44. #define    NPAT    80            /* Length, pattern.        */
  45. #define    HUGE    1000            /* A rather large number.    */
  46. #define NSRCH    128            /* Undoable search commands.    */
  47. #define    NXNAME    64            /* Length, extended command.    */
  48. #define    NKNAME    20            /* Length, key names        */
  49. /*
  50.  * Universal.
  51.  */
  52. #define    FALSE    0            /* False, no, bad, etc.        */
  53. #define    TRUE    1            /* True, yes, good, etc.    */
  54. #define    ABORT    2            /* Death, ^G, abort, etc.    */
  55.  
  56. /*
  57.  * These flag bits keep track of
  58.  * some aspects of the last command. The CFCPCN
  59.  * flag controls goal column setting. The CFKILL
  60.  * flag controls the clearing versus appending
  61.  * of data in the kill buffer.
  62.  */
  63. #define    CFCPCN    0x0001            /* Last command was C-P, C-N    */
  64. #define    CFKILL    0x0002            /* Last command was a kill    */
  65.  
  66. /*
  67.  * File I/O.
  68.  */
  69. #define    FIOSUC    0            /* Success.            */
  70. #define    FIOFNF    1            /* File not found.        */
  71. #define    FIOEOF    2            /* End of file.            */
  72. #define    FIOERR    3            /* Error.            */
  73.  
  74. /*
  75.  * Directory I/O.
  76.  */
  77. #define    DIOSUC    0            /* Success.            */
  78. #define    DIOEOF    1            /* End of file.            */
  79. #define    DIOERR    2            /* Error.            */
  80.  
  81. /*
  82.  * Display colors.
  83.  */
  84. #define    CNONE    0            /* Unknown color.        */
  85. #define    CTEXT    1            /* Text color.            */
  86. #define    CMODE    2            /* Mode line color.        */
  87.  
  88. /*
  89.  * global mode
  90.  */
  91. #define    MBSMAP    0x0001            /* Map bs<->del            */
  92. #define MFLOW    0x0002            /* Use ^^ for ^Q and ^/ for ^S    */
  93. #define    MINDENT    0x0004            /* autoindent            */
  94. #define    MFILL    0x0008            /* fill mode            */
  95.  
  96. /*
  97.  * Flags for "eread".
  98.  */
  99. #define    EFFUNC    0x0001            /* Autocomplete functions.    */
  100. #define EFBUF    0x0002            /* Autocomplete buffers.    */
  101. #define EFFILE    0x0004            /* " files (maybe someday)    */
  102. #define    EFAUTO    0x0007            /* Some autocompleteion on    */
  103. #define    EFNEW    0x0008            /* New prompt.            */
  104. #define    EFCR    0x0010            /* Echo CR at end; last read.    */
  105.  
  106. /*
  107.  * Flags for "getkey".
  108.  */
  109. #define KQUOTE    0x0001            /* Get raw character        */
  110. #define    KNOMAC    0x0002            /* Don't record for macros    */
  111. #define    KPROMPT 0x0004            /* do delayed prompting        */
  112.  
  113. /*
  114.  * Flags for "ldelete"/"kinsert"
  115.  */
  116.  
  117. #define KNONE    0
  118. #define KFORW    1
  119. #define KBACK    2
  120.  
  121. /*
  122.  * Keys are represented inside using an 11 bit
  123.  * keyboard code. The transformation between the keys on
  124.  * the keyboard and 11 bit code is done by terminal specific
  125.  * code in the "kbd.c" file. The actual character is stored
  126.  * in 8 bits (DEC multinationals work); there is also a control
  127.  * flag KCTRL, a meta flag KMETA, and a control-X flag KCTLX.
  128.  * ASCII control characters are always represented using the
  129.  * KCTRL form. Although the C0 control set is free, it is
  130.  * reserved for C0 controls because it makes the communication
  131.  * between "getkey" and "getkbd" easier. The funny keys get
  132.  * mapped into the C1 control area. The KEY type is typedefed in
  133.  * sysdef.h, as it may depeond on compiler/machine.
  134.  */
  135. #define    NKEYS    2048            /* 11 bit code.            */
  136.  
  137. #define    METACH    0x1B            /* M- prefix,   Control-[, ESC    */
  138. #define    CTMECH    0x1C            /* C-M- prefix, Control-\    */
  139. #define    EXITCH    0x1D            /* Exit level,  Control-]    */
  140. #define    CTRLCH    0x1E            /* C- prefix,    Control-^    */
  141. #define    HELPCH    0x1F            /* Help key,    Control-_    */
  142.  
  143. #define    KCHAR    0x00FF            /* The basic character code.    */
  144. #define    KCTRL    0x0100            /* Control flag.        */
  145. #define    KMETA    0x0200            /* Meta flag.            */
  146. #define    KCTLX    0x0400            /* Control-X flag.        */
  147.  
  148. #define    KFIRST    0x0080            /* First special.        */
  149. #define    KLAST    0x009F            /* Last special.        */
  150.  
  151. #define    KRANDOM    0x0080            /* A "no key" code.        */
  152. #define    K01    0x0081            /* Use these names to define    */
  153. #define    K02    0x0082            /* the special keys on your    */
  154. #define    K03    0x0083            /* terminal.            */
  155. #define    K04    0x0084
  156. #define    K05    0x0085
  157. #define    K06    0x0086
  158. #define    K07    0x0087
  159. #define    K08    0x0088
  160. #define    K09    0x0089
  161. #define    K0A    0x008A
  162. #define    K0B    0x008B
  163. #define    K0C    0x008C
  164. #define    K0D    0x008D
  165. #define    K0E    0x008E
  166. #define    K0F    0x008F
  167. #define    K10    0x0090
  168. #define    K11    0x0091
  169. #define    K12    0x0092
  170. #define    K13    0x0093
  171. #define    K14    0x0094
  172. #define    K15    0x0095
  173. #define    K16    0x0096
  174. #define    K17    0x0097
  175. #define    K18    0x0098
  176. #define    K19    0x0099
  177. #define    K1A    0x009A
  178. #define    K1B    0x009B
  179. #define    K1C    0x009C
  180. #define    K1D    0x009D
  181. #define    K1E    0x009E
  182. #define    K1F    0x009F
  183.  
  184. #ifndef SEOL        /* needed for OSK, where '\r' == '\n' */
  185. #  define SEOL '\n'
  186. #endif
  187.  
  188. /*
  189.  * These flags, and the macros below them,
  190.  * make up a do-it-yourself set of "ctype" macros that
  191.  * understand the DEC multinational set, and let me ask
  192.  * a slightly different set of questions.
  193.  */
  194. #define    _W    0x01            /* Word.            */
  195. #define    _U    0x02            /* Upper case letter.        */
  196. #define    _L    0x04            /* Lower case letter.        */
  197. #define    _C    0x08            /* Control.            */
  198. #define _P    0x10            /* end of sentence punctuation    */
  199.  
  200. #define    ISWORD(c)    ((cinfo[(c)]&_W)!=0)
  201. #define    ISCTRL(c)    ((cinfo[(c)]&_C)!=0)
  202. #define    ISUPPER(c)    ((cinfo[(c)]&_U)!=0)
  203. #define    ISLOWER(c)    ((cinfo[(c)]&_L)!=0)
  204. #define    ISEOSP(c)    ((cinfo[(c)]&_P)!=0)
  205. #define    TOUPPER(c)    ((c)-0x20)
  206. #define    TOLOWER(c)    ((c)+0x20)
  207.  
  208. /*
  209.  * generally useful thing for chars
  210.  */
  211. #define CCHR(x)        ((x)-'@')
  212.  
  213. /*
  214.  * All repeated structures are kept as linked lists of structures.
  215.  * All of these start with a LIST structure (except lines, which
  216.  * have their own abstraction). This will allow for
  217.  * later conversion to generic list manipulation routines should
  218.  * I decide to do that. it does mean that there are four extra
  219.  * bytes per window. I feel that this is an acceptable price,
  220.  * considering that there are usually only one or two windows.
  221.  */
  222. typedef struct LIST {
  223.     union {
  224.         struct SYMBOL    *l_sp;
  225.         struct WINDOW    *l_wp;
  226.         struct BUFFER    *l_bp;
  227.         struct LIST    *l_nxt;
  228.     } l_p;
  229.     char    *l_name;
  230. } LIST;
  231. /*
  232.  * Usual hack - to keep from uglifying the code with lotsa
  233.  * references through the union, we #define something for it.
  234.  */
  235. #define    l_next    l_p.l_nxt
  236.  
  237. /*
  238.  * The symbol table links editing functions
  239.  * to names. Entries in the key map point at the symbol
  240.  * table entry.
  241.  */
  242. typedef    struct    SYMBOL {
  243.     LIST    s_list;            /* List chain.            */
  244.     int    (*s_funcp)();        /* Function.            */
  245. #ifdef    HASH
  246.     short    s_flags;        /* Flags for this symbol    */
  247. #endif
  248. }    SYMBOL;
  249. #define    s_symp    s_list.l_p.l_sp
  250. #define s_name    s_list.l_name
  251. #ifdef    HASH
  252. #define SFEND    0x001            /* End of has list        */
  253. #endif
  254.  
  255. /*
  256.  * There is a window structure allocated for
  257.  * every active display window. The windows are kept in a
  258.  * big list, in top to bottom screen order, with the listhead at
  259.  * "wheadp". Each window contains its own values of dot and mark.
  260.  * The flag field contains some bits that are set by commands
  261.  * to guide redisplay; although this is a bit of a compromise in
  262.  * terms of decoupling, the full blown redisplay is just too
  263.  * expensive to run for every input character. 
  264.  */
  265. typedef    struct    WINDOW {
  266.     LIST    w_list;            /* List header               */
  267.     struct    BUFFER *w_bufp;        /* Buffer displayed in window    */
  268.     struct    LINE *w_linep;        /* Top line in the window    */
  269.     struct    LINE *w_dotp;        /* Line containing "."        */
  270.     struct    LINE *w_markp;        /* Line containing "mark"    */
  271.     short    w_doto;            /* Byte offset for "."        */
  272.     short    w_marko;        /* Byte offset for "mark"    */
  273.     char    w_toprow;        /* Origin 0 top row of window    */
  274.     char    w_ntrows;        /* # of rows of text in window    */
  275.     char    w_force;        /* If NZ, forcing row.        */
  276.     char    w_flag;            /* Flags.            */
  277. }    WINDOW;
  278. #define    w_wndp    w_list.l_p.l_wp
  279. #define w_name    w_list.l_name
  280.  
  281. /*
  282.  * Window flags are set by command processors to
  283.  * tell the display system what has happened to the buffer
  284.  * mapped by the window. Setting "WFHARD" is always a safe thing
  285.  * to do, but it may do more work than is necessary. Always try
  286.  * to set the simplest action that achieves the required update.
  287.  * Because commands set bits in the "w_flag", update will see
  288.  * all change flags, and do the most general one.
  289.  */
  290. #define    WFFORCE    0x01            /* Force reframe.        */
  291. #define    WFMOVE    0x02            /* Movement from line to line.    */
  292. #define    WFEDIT    0x04            /* Editing within a line.    */
  293. #define    WFHARD    0x08            /* Better to a full display.    */
  294. #define    WFMODE    0x10            /* Update mode line.        */
  295.  
  296. /*
  297.  * Text is kept in buffers. A buffer header, described
  298.  * below, exists for every buffer in the system. The buffers are
  299.  * kept in a big list, so that commands that search for a buffer by
  300.  * name can find the buffer header. There is a safe store for the
  301.  * dot and mark in the header, but this is only valid if the buffer
  302.  * is not being displayed (that is, if "b_nwnd" is 0). The text for
  303.  * the buffer is kept in a circularly linked list of lines, with
  304.  * a pointer to the header line in "b_linep".
  305.  */
  306. typedef    struct    BUFFER {
  307.     LIST    b_list;            /* buffer list pointer        */
  308.     struct    BUFFER *b_altb;        /* Link to alternate buffer    */
  309.     struct    LINE *b_dotp;        /* Link to "." LINE structure    */
  310.     struct    LINE *b_markp;        /* The same as the above two,    */
  311.     struct    LINE *b_linep;        /* Link to the header LINE    */
  312.     short    b_doto;            /* Offset of "." in above LINE    */
  313.     short    b_marko;        /* but for the "mark"        */
  314.     char    b_nwnd;            /* Count of windows on buffer    */
  315.     char    b_flag;            /* Flags            */
  316.     char    b_fname[NFILEN];    /* File name            */
  317. }    BUFFER;
  318. #define    b_bufp    b_list.l_p.l_bp
  319. #define b_bname    b_list.l_name
  320.  
  321. #define    BFCHG    0x01            /* Changed.            */
  322. #define    BFBAK    0x02            /* Need to make a backup.    */
  323.  
  324. /*
  325.  * This structure holds the starting position
  326.  * (as a line/offset pair) and the number of characters in a
  327.  * region of a buffer. This makes passing the specification
  328.  * of a region around a little bit easier.
  329.  */
  330. typedef    struct    {
  331.     struct    LINE *r_linep;        /* Origin LINE address.        */
  332.     short    r_offset;        /* Origin LINE offset.        */
  333.     RSIZE    r_size;            /* Length in characters.    */
  334. }    REGION;
  335.  
  336. /*
  337.  * All text is kept in circularly linked
  338.  * lists of "LINE" structures. These begin at the
  339.  * header line (which is the blank line beyond the
  340.  * end of the buffer). This line is pointed to by
  341.  * the "BUFFER". Each line contains a the number of
  342.  * bytes in the line (the "used" size), the size
  343.  * of the text array, and the text. The end of line
  344.  * is not stored as a byte; it's implied. Future
  345.  * additions will include update hints, and a
  346.  * list of marks into the line.
  347.  */
  348. typedef    struct    LINE {
  349.     struct    LINE *l_fp;        /* Link to the next line    */
  350.     struct    LINE *l_bp;        /* Link to the previous line    */
  351.     short    l_size;            /* Allocated size        */
  352.     short    l_used;            /* Used size            */
  353. #ifdef    PCC
  354.     char    l_text[1];        /* A bunch of characters.    */
  355. #else
  356.     char    l_text[];        /* A bunch of characters.    */
  357. #endif
  358. }    LINE;
  359.  
  360. /*
  361.  * The rationale behind these macros is that you
  362.  * could (with some editing, like changing the type of a line
  363.  * link from a "LINE *" to a "REFLINE", and fixing the commands
  364.  * like file reading that break the rules) change the actual
  365.  * storage representation of lines to use something fancy on
  366.  * machines with small address spaces.
  367.  */
  368. #define    lforw(lp)    ((lp)->l_fp)
  369. #define    lback(lp)    ((lp)->l_bp)
  370. #define    lgetc(lp, n)    ((lp)->l_text[(n)]&0xFF)
  371. #define    lputc(lp, n, c)    ((lp)->l_text[(n)]=(c))
  372. #define    llength(lp)    ((lp)->l_used)
  373. #define    ltext(lp)    ((lp)->l_text)
  374.  
  375. /*
  376.  * Externals.
  377.  */
  378. extern    int    thisflag;
  379. extern    int    lastflag;
  380. extern    int    curgoal;
  381. extern    int    epresf;
  382. extern    int    sgarbf;
  383. extern    int    mode;
  384. extern    WINDOW    *curwp;
  385. extern    BUFFER    *curbp;
  386. extern    WINDOW    *wheadp;
  387. extern    BUFFER    *bheadp;
  388. extern    KEY    kbdm[];
  389. extern    KEY    *kbdmip;
  390. extern    KEY    *kbdmop;
  391. extern    KEY    getkey();
  392. extern    char    pat[];
  393. extern    SYMBOL    *symbol[];
  394. extern    SYMBOL    *binding[];
  395. extern    BUFFER    *bfind();
  396. extern    WINDOW    *popbuf();
  397. extern    WINDOW    *wpopup();
  398. extern    LINE    *lalloc();
  399. extern  int    nrow;
  400. extern  int    ncol;
  401. extern    char    *version;
  402. extern    int    ttrow;
  403. extern    int    ttcol;
  404. extern    int    tceeol;
  405. extern    int    tcinsl;
  406. extern    int    tcdell;
  407. extern    char    cinfo[];
  408. extern    char    *keystrings[];
  409. extern    SYMBOL    *symlookup();
  410. VOID        update();
  411. VOID        keyname();
  412. /*
  413.  * Standard I/O.
  414.  */
  415. extern    char    *strcpy();
  416. extern    char    *strcat();
  417. extern    char    *malloc();
  418.